{
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-02-28T02:13:28.846156Z",
     "start_time": "2025-02-28T02:13:28.000007Z"
    }
   },
   "source": [
    "from sklearn.feature_extraction import DictVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
    "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
    "from sklearn.feature_selection import VarianceThreshold\n",
    "from sklearn.decomposition import PCA\n",
    "import jieba\n",
    "import numpy as np\n",
    "from sklearn.impute import SimpleImputer"
   ],
   "outputs": [],
   "execution_count": 1
  },
  {
   "cell_type": "markdown",
   "source": "# 1 数据中含有字符串的时候，如何做特征抽取",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def dict_vec():\n",
    "    \"\"\"\n",
    "    字典数据抽取\n",
    "    #Vectorizer中文含义是矢量器的含义\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # 实例化一个对象\n",
    "    #矩阵中存在大量的0，sparse存储只记录非零位置，节省空间的作用\n",
    "    # sparse参数说明：\n",
    "    # - 当sparse=True（默认）时返回稀疏矩阵（scipy.sparse矩阵），只存储非零元素的位置和值，节省内存\n",
    "    # - 当sparse=False时返回密集矩阵（numpy.ndarray），适合小数据集直观查看\n",
    "    dict_1 = DictVectorizer(sparse=True)\n",
    "    #每个样本都是一个字典，有三个样本\n",
    "    # 调用fit_transform:作用是把字典数据转换成特征值,注意字典格式要求：\n",
    "    # 1. 键代表特征名称（如city/temperature）\n",
    "    # 2. 值对应特征取值（字符串类型会被视为类别特征，数值类型会作为连续特征）\n",
    "    data = dict_1.fit_transform([{'city': '北京', 'temperature': 100},\n",
    "                                 {'city': '上海', 'temperature': 60},\n",
    "                                 {'city': '深圳', 'temperature': 30}])\n",
    "    print(\"转换后的特征矩阵：\\n\", data)\n",
    "    print('-' * 50)\n",
    "\n",
    "    # 获取特征名称列表，展示特征工程后的列含义\n",
    "    # 输出格式说明：\n",
    "    # ['city=北京', 'city=上海', 'city=深圳', 'temperature']\n",
    "    print(\"特征名称列表：\\n\", dict_1.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "\n",
    "    # 逆向转换演示：将特征矩阵还原为原始字典表示\n",
    "    # 注意：对于one-hot编码的特征，会还原为原始的键值对形式\n",
    "    print(\"逆向转换结果：\\n\", dict_1.inverse_transform(data))\n",
    "\n",
    "\n",
    "dict_vec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T02:13:28.851139Z",
     "start_time": "2025-02-28T02:13:28.846156Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "转换后的特征矩阵：\n",
      " <Compressed Sparse Row sparse matrix of dtype 'float64'\n",
      "\twith 6 stored elements and shape (3, 4)>\n",
      "  Coords\tValues\n",
      "  (0, 1)\t1.0\n",
      "  (0, 3)\t100.0\n",
      "  (1, 0)\t1.0\n",
      "  (1, 3)\t60.0\n",
      "  (2, 2)\t1.0\n",
      "  (2, 3)\t30.0\n",
      "--------------------------------------------------\n",
      "特征名称列表：\n",
      " ['city=上海' 'city=北京' 'city=深圳' 'temperature']\n",
      "--------------------------------------------------\n",
      "逆向转换结果：\n",
      " [{'city=北京': np.float64(1.0), 'temperature': np.float64(100.0)}, {'city=上海': np.float64(1.0), 'temperature': np.float64(60.0)}, {'city=深圳': np.float64(1.0), 'temperature': np.float64(30.0)}]\n"
     ]
    }
   ],
   "execution_count": 2
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2 一段英文文本如何变为数值类型"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def cou_vec():\n",
    "    # 实例化CountVectorizer\n",
    "    # max_df, min_df整数：指每个词的所有文档词频数不小于最小值，出现该词的文档数目小于等于max_df\n",
    "    # max_df, min_df小数：某个词的出现的次数／所有文档数量\n",
    "    # min_df=2\n",
    "    # 默认会去除单个字母的单词，默认认为这个词对整个样本没有影响,认为其没有语义\n",
    "    vector = CountVectorizer(min_df=2)\n",
    "    # 调用fit_transform输入并转换数据\n",
    "    # 执行特征提取：将文本转换为词频矩阵\n",
    "    # 返回结果：\n",
    "    # - 稀疏矩阵（默认），存储格式为CSR格式\n",
    "    # - 每行对应一个文档，每列对应一个词项\n",
    "    res = vector.fit_transform(\n",
    "        [\"life is short,i like python life\",\n",
    "         \"life is too long,i dislike python\",\n",
    "         \"life is short\"])\n",
    "    # 输出特征词汇表（按字母顺序排序）\n",
    "    print(vector.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(res)\n",
    "    print('-' * 50)\n",
    "    print(type(res))\n",
    "    # 对照feature_names，标记每个词出现的次数\n",
    "    print('-' * 50)\n",
    "    print(res.toarray())\n",
    "    print('-' * 50)\n",
    "    #拿每个样本里的特征进行显示\n",
    "    print(vector.inverse_transform(res))\n",
    "\n",
    "\n",
    "cou_vec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T02:13:28.858608Z",
     "start_time": "2025-02-28T02:13:28.852143Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['is' 'life' 'python' 'short']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 10 stored elements and shape (3, 4)>\n",
      "  Coords\tValues\n",
      "  (0, 1)\t2\n",
      "  (0, 0)\t1\n",
      "  (0, 3)\t1\n",
      "  (0, 2)\t1\n",
      "  (1, 1)\t1\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (2, 1)\t1\n",
      "  (2, 0)\t1\n",
      "  (2, 3)\t1\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[1 2 1 1]\n",
      " [1 1 1 0]\n",
      " [1 1 0 1]]\n",
      "--------------------------------------------------\n",
      "[array(['life', 'is', 'short', 'python'], dtype='<U6'), array(['life', 'is', 'python'], dtype='<U6'), array(['life', 'is', 'short'], dtype='<U6')]\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 一段汉字文本如何数值化，对于汉字不能用空格来分割"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def count_vec():\n",
    "    \"\"\"\n",
    "    对文本进行特征值化,单个汉字单个字母不统计，因为单个汉字字母没有意义\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([\"人生苦短，我 喜欢 python python\", \"人生漫长，不用 python\"])\n",
    "\n",
    "    print(cv.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(data)  #稀疏存储，只记录非零位置\n",
    "    print('-' * 50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "count_vec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T02:13:28.866115Z",
     "start_time": "2025-02-28T02:13:28.858608Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['python' '不用' '人生漫长' '人生苦短' '喜欢']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 6 stored elements and shape (2, 5)>\n",
      "  Coords\tValues\n",
      "  (0, 3)\t1\n",
      "  (0, 4)\t1\n",
      "  (0, 0)\t2\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (1, 1)\t1\n",
      "--------------------------------------------------\n",
      "[[2 0 0 1 1]\n",
      " [1 1 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 1.3 掌握如何对中文进行分词"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "def cutword():\n",
    "    \"\"\"\n",
    "    通过jieba对中文进行分词\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    con1 = jieba.cut(\"今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。\")\n",
    "\n",
    "    con2 = jieba.cut(\"我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。\")\n",
    "\n",
    "    con3 = jieba.cut(\n",
    "        \"如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。\")\n",
    "\n",
    "    # 转换成列表\n",
    "    print(type(con1))\n",
    "    print('-' * 50)\n",
    "    # 把生成器转换成列表\n",
    "    content1 = list(con1)\n",
    "    content2 = list(con2)\n",
    "    content3 = list(con3)\n",
    "    print(content1)\n",
    "    print(content2)\n",
    "    print(content3)\n",
    "    # 把列表转换成字符串,每个词之间用空格隔开\n",
    "    print('-' * 50)\n",
    "    c1 = ' '.join(content1)  # 转换为字符串\n",
    "    c2 = ' '.join(content2)\n",
    "    c3 = ' '.join(content3)\n",
    "    print('+' * 50)\n",
    "\n",
    "    return c1, c2, c3  # 这里返回的类型是字符串\n",
    "\n",
    "\n",
    "def chinese_vec():\n",
    "    \"\"\"\n",
    "    中文特征值化\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()  #jieba分词好的中文文本\n",
    "    print('-' * 50)\n",
    "    print(c1)\n",
    "    print(c2)\n",
    "    print(c3)\n",
    "    print('-' * 50)\n",
    "\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([c1, c2, c3], )\n",
    "    print('-' * 50)\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    print(cv.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(data.toarray())\n",
    "    print('-' * 50)\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "# cutword()\n",
    "chinese_vec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T02:13:29.209347Z",
     "start_time": "2025-02-28T02:13:28.867119Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Building prefix dict from the default dictionary ...\n",
      "Loading model from cache C:\\Users\\陈其志\\AppData\\Local\\Temp\\jieba.cache\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loading model cost 0.334 seconds.\n",
      "Prefix dict has been built successfully.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "++++++++++++++++++++++++++++++++++++++++++++++++++\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。\n",
      "我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。\n",
      "如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "--------------------------------------------------\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 37 stored elements and shape (3, 36)>\n",
      "  Coords\tValues\n",
      "  (0, 6)\t2\n",
      "  (0, 26)\t2\n",
      "  (0, 22)\t2\n",
      "  (0, 12)\t1\n",
      "  (0, 32)\t1\n",
      "  (0, 31)\t1\n",
      "  (0, 14)\t1\n",
      "  (0, 24)\t1\n",
      "  (0, 19)\t1\n",
      "  (0, 27)\t1\n",
      "  (0, 2)\t1\n",
      "  (0, 20)\t1\n",
      "  (1, 18)\t3\n",
      "  (1, 28)\t2\n",
      "  (1, 23)\t1\n",
      "  (1, 7)\t1\n",
      "  (1, 8)\t1\n",
      "  (1, 3)\t1\n",
      "  (1, 9)\t1\n",
      "  (1, 35)\t1\n",
      "  (1, 17)\t1\n",
      "  (1, 34)\t1\n",
      "  (2, 18)\t1\n",
      "  (2, 16)\t1\n",
      "  (2, 11)\t1\n",
      "  (2, 0)\t1\n",
      "  (2, 21)\t1\n",
      "  (2, 4)\t4\n",
      "  (2, 25)\t1\n",
      "  (2, 5)\t3\n",
      "  (2, 1)\t1\n",
      "  (2, 29)\t2\n",
      "  (2, 13)\t1\n",
      "  (2, 30)\t1\n",
      "  (2, 10)\t1\n",
      "  (2, 15)\t1\n",
      "  (2, 33)\t1\n",
      "--------------------------------------------------\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "--------------------------------------------------\n",
      "[[0 0 1 0 0 0 2 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 2 0 1 0 2 1 0 0 0 1 1 0 0 0]\n",
      " [0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 1 3 0 0 0 0 1 0 0 0 0 2 0 0 0 0 0 1 1]\n",
      " [1 1 0 0 4 3 0 0 0 0 1 1 0 1 0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 2 1 0 0 1 0 0]]\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "execution_count": 5
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 1.4 tf-idf"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "# 规范{'l1'，'l2'}，默认='l2'\n",
    "# 每个输出行都有单位范数，或者：\n",
    "# 'l2'：向量元素的平方和为 1。当应用 l2 范数时，两个向量之间的余弦相似度是它们的点积。\n",
    "# 'l1'：向量元素的绝对值之和为 1。参见preprocessing.normalize。\n",
    "# 通过在文档频率上加一来平滑 idf 权重，就好像看到一个额外的文档包含集合中的每个术语恰好一次。防止零分裂。\n",
    "# 比如训练集中有某个词，测试集中没有，就是生僻词，就会造成n(x)分母为零，log(n/n(x)),从而出现零分裂\n",
    "def tf_idf_vec():\n",
    "    \"\"\"\n",
    "    中文文本特征提取（TF-IDF 计算）\n",
    "    步骤：\n",
    "    1. 调用分词函数获取三个中文文档的分词结果\n",
    "    2. 使用 TfidfVectorizer 计算 TF-IDF 矩阵\n",
    "    3. 输出特征词、矩阵类型及具体数值\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()\n",
    "\n",
    "    print(c1, c2, c3)\n",
    "    # print(type([c1, c2, c3]))\n",
    "    tf = TfidfVectorizer(smooth_idf=True)  # smooth_idf:平滑idf权重,默认True，防止除零错误\n",
    "\n",
    "    data = tf.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(tf.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(type(data))\n",
    "    print('-' * 50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "tf_idf_vec()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T02:13:29.214Z",
     "start_time": "2025-02-28T02:13:29.209347Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "++++++++++++++++++++++++++++++++++++++++++++++++++\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。 我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。 如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[0.         0.         0.21821789 0.         0.         0.\n",
      "  0.43643578 0.         0.         0.         0.         0.\n",
      "  0.21821789 0.         0.21821789 0.         0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.43643578 0.\n",
      "  0.21821789 0.         0.43643578 0.21821789 0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.         0.        ]\n",
      " [0.         0.         0.         0.2410822  0.         0.\n",
      "  0.         0.2410822  0.2410822  0.2410822  0.         0.\n",
      "  0.         0.         0.         0.         0.         0.2410822\n",
      "  0.55004769 0.         0.         0.         0.         0.2410822\n",
      "  0.         0.         0.         0.         0.48216441 0.\n",
      "  0.         0.         0.         0.         0.2410822  0.2410822 ]\n",
      " [0.15698297 0.15698297 0.         0.         0.62793188 0.47094891\n",
      "  0.         0.         0.         0.         0.15698297 0.15698297\n",
      "  0.         0.15698297 0.         0.15698297 0.15698297 0.\n",
      "  0.1193896  0.         0.         0.15698297 0.         0.\n",
      "  0.         0.15698297 0.         0.         0.         0.31396594\n",
      "  0.15698297 0.         0.         0.15698297 0.         0.        ]]\n"
     ]
    }
   ],
   "execution_count": 6
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 2 特征处理，不同的特征拉到到同一个量纲"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def mm():\n",
    "    \"\"\"\n",
    "    归一化处理\n",
    "    :return: NOne\n",
    "    \"\"\"\n",
    "    # 归一化缺点 容易受极值的影响\n",
    "    #feature_range代表特征值范围，一般设置为(0,1),或者(-1,1),默认是(0,1)\n",
    "    mm = MinMaxScaler(feature_range=(0, 1)) #feature_range=(0,1):归一化到0-1之间\n",
    "    # 在训练集上计算最小值和最大值，然后在测试集上使用相同的比例进行缩放\n",
    "    data = mm.fit_transform([[90, 2, 10, 40], [60, 4, 15, 45], [75, 3, 13, 46]])\n",
    "\n",
    "    print(data)\n",
    "    out = mm.transform([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])\n",
    "    print(out)\n",
    "    return None\n",
    "    #transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值\n",
    "\n",
    "\n",
    "mm()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T02:13:29.221943Z",
     "start_time": "2025-02-28T02:13:29.214Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         0.         0.         0.        ]\n",
      " [0.         1.         1.         0.83333333]\n",
      " [0.5        0.5        0.6        1.        ]]\n",
      "[[-1.96666667  0.         -1.4        -6.        ]\n",
      " [-1.83333333  2.         -0.6        -5.33333333]\n",
      " [-1.7         4.          0.2        -4.66666667]]\n"
     ]
    }
   ],
   "execution_count": 7
  },
  {
   "cell_type": "code",
   "source": [
    "def stand():\n",
    "    \"\"\"\n",
    "    标准化缩放，不是标准正太分布，只均值为0，方差为1的分布\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    std = StandardScaler()\n",
    "\n",
    "    data = std.fit_transform([[1., -1., 3.], [2., 4., 2.], [4., 6., -1.]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    print(std.mean_)\n",
    "    print('-' * 50)\n",
    "    print(std.var_)\n",
    "    print(std.n_samples_seen_)  # 样本数\n",
    "    return None\n",
    "\n",
    "\n",
    "stand()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T02:13:29.227921Z",
     "start_time": "2025-02-28T02:13:29.221943Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1.06904497 -1.35873244  0.98058068]\n",
      " [-0.26726124  0.33968311  0.39223227]\n",
      " [ 1.33630621  1.01904933 -1.37281295]]\n",
      "--------------------------------------------------\n",
      "[2.33333333 3.         1.33333333]\n",
      "--------------------------------------------------\n",
      "[1.55555556 8.66666667 2.88888889]\n",
      "3\n"
     ]
    }
   ],
   "execution_count": 8
  },
  {
   "cell_type": "code",
   "source": [
    "std1 = StandardScaler()\n",
    "#为了证明上面输出的结果的均值是为0的，方差为1\n",
    "data1 = std1.fit_transform([[-1.06904497, -1.35873244, 0.98058068],\n",
    "                            [-0.26726124, 0.33968311, 0.39223227],\n",
    "                            [1.33630621, 1.01904933, -1.37281295]])\n",
    "# print(data1)  #这个并不是我们想看的，没意义\n",
    "# 均值\n",
    "print(std1.mean_)\n",
    "# 方差\n",
    "print(std1.var_)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-28T02:13:29.236027Z",
     "start_time": "2025-02-28T02:13:29.227921Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 0. 0.]\n",
      "[1.         1.         1.00000001]\n"
     ]
    }
   ],
   "execution_count": 9
  },
  {
   "cell_type": "code",
   "source": "(np.square(1 - 2.333) + np.square(2 - 2.333) + np.square(4 - 2.333)) / 3",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-28T02:13:29.242680Z",
     "start_time": "2025-02-28T02:13:29.236027Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(1.5555556666666668)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 10
  },
  {
   "cell_type": "code",
   "source": "(1 - 2.333) / np.sqrt(1.55555)",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-28T02:13:29.249521Z",
     "start_time": "2025-02-28T02:13:29.242680Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(-1.068779614944516)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 11
  },
  {
   "cell_type": "markdown",
   "source": [
    "## transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值,不会重新计算均值方差"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 3 缺失值处理\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "#下面是填补，针对删除，可以用pd和np\n",
    "def im():\n",
    "    \"\"\"\n",
    "    缺失值处理\n",
    "    :return:NOne\n",
    "    \"\"\"\n",
    "    # NaN, nan,缺失值必须是这种形式，如果是？号(或者其他符号)，就要replace换成这种\n",
    "    im = SimpleImputer(missing_values=np.nan, strategy='mean')\n",
    "\n",
    "    data = im.fit_transform([[1, 2], [np.nan, 3], [7, 6], [3, 2]])\n",
    "\n",
    "    print(data)\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "im()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T02:13:29.256143Z",
     "start_time": "2025-02-28T02:13:29.249521Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         2.        ]\n",
      " [3.66666667 3.        ]\n",
      " [7.         6.        ]\n",
      " [3.         2.        ]]\n"
     ]
    }
   ],
   "execution_count": 12
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 4 降维\n",
    "# 降维就是特征数变少\n",
    "# 降维可以提高模型训练速度（模型的参数减少了）"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def var():\n",
    "    \"\"\"\n",
    "    特征选择-删除低方差的特征\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    #默认只删除方差为0,threshold是方差阈值，删除比这个值小的那些特征\n",
    "    var = VarianceThreshold(threshold=0.6)\n",
    "\n",
    "    data = var.fit_transform([[0, 2, 0, 3],\n",
    "                              [0, 1, 4, 3],\n",
    "                              [0, 1, 1, 3]])\n",
    "\n",
    "    print(data)\n",
    "    # 获得剩余的特征的列编号\n",
    "    print('The surport is %s' % var.get_support(True))\n",
    "    return None\n",
    "\n",
    "\n",
    "var()\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T02:13:29.263892Z",
     "start_time": "2025-02-28T02:13:29.256143Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0]\n",
      " [4]\n",
      " [1]]\n",
      "The surport is [2]\n"
     ]
    }
   ],
   "execution_count": 13
  },
  {
   "cell_type": "code",
   "source": [
    "def pca():\n",
    "    \"\"\"\n",
    "    主成分分析进行特征降维\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # n_ components:小数 0~1 90% 业界选择 90~95%\n",
    "\n",
    "    # 当n_components的值为0到1之间的浮点数时，表示我们希望保留的主成分解释的方差比例。\n",
    "    # 具体而言，n_components=0.9表示我们希望选择足够的主成分，以使它们解释数据方差的90%。\n",
    "\n",
    "    # n_components如果是整数   减少到的特征数量\n",
    "    # 原始数据方差\n",
    "    print(np.var(np.array([[2, 8, 4, 5], [6, 3, 0, 8], [5, 4, 9, 1]]), axis=0).sum())\n",
    "    print('-' * 50)\n",
    "    pca = PCA(n_components=0.9)\n",
    "\n",
    "    data = pca.fit_transform([[2, 8, 4, 5], [6, 3, 0, 8], [5, 4, 9, 1]])\n",
    "\n",
    "    print(data)\n",
    "    print(type(data))\n",
    "    #计算data的方差\n",
    "    print(np.var(data, axis=0).sum())\n",
    "    print('-' * 50)\n",
    "    print(pca.explained_variance_ratio_)\n",
    "    # 计算data的方差占总方差的比例\n",
    "    print(pca.explained_variance_ratio_.sum())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "pca()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2025-02-28T02:13:29.275408Z",
     "start_time": "2025-02-28T02:13:29.263892Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29.333333333333336\n",
      "--------------------------------------------------\n",
      "[[-1.28620952e-15  3.82970843e+00]\n",
      " [-5.74456265e+00 -1.91485422e+00]\n",
      " [ 5.74456265e+00 -1.91485422e+00]]\n",
      "<class 'numpy.ndarray'>\n",
      "29.333333333333332\n",
      "--------------------------------------------------\n",
      "[0.75 0.25]\n",
      "1.0\n"
     ]
    }
   ],
   "execution_count": 14
  },
  {
   "cell_type": "code",
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "x = np.random.rand(10000)  #每个的概率\n",
    "t = np.arange(len(x))\n",
    "plt.plot(t, x, 'g.', label=\"Uniform Distribution\")\n",
    "plt.legend(loc=\"upper left\")\n",
    "plt.grid()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-02-28T02:13:29.908397Z",
     "start_time": "2025-02-28T02:13:29.275408Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 15
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
